package utils

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"strconv"
	"time"
)

func ExceptionCatch() {
	if r := recover(); r != nil {
		fmt.Println("Recovered in f", r)
	}
}

func Throw(err error) {
	if err != nil {
		panic(err)
	}
}

func ToJsonString(data interface{}) string {
	return string(toJson(data))
}

func StrToArr(data string) []string {
	var out []string
	_ = json.Unmarshal([]byte(data), &out)
	return out
}

func ToJsonBytes(data interface{}) []byte {
	return toJson(data)
}

func toJson(data interface{}) []byte {
	if data == nil {
		return nil
	}
	marshal, _ := json.Marshal(data)
	return marshal
}

// SqlLike sql模糊查询
func SqlLike(col *string) string {
	return fmt.Sprintf("%v", "%"+*col+"%")
}

// RandZone 生成区间 [1, 10] 的随机整数
func RandZone(min, max int) int {
	// 设置随机种子
	rand.Seed(time.Now().UnixNano())

	// 生成区间 [1, 10] 的随机整数
	randomNumber := rand.Intn(max-min+1) + min
	return randomNumber
}

func GetRandomStrings(arr []string, n int) ([]string, error) {
	// 检查请求的数量是否大于数组长度
	if n > len(arr) {
		return nil, fmt.Errorf("requested number %d is greater than array length %d", n, len(arr))
	}

	// 设置随机种子
	rand.Seed(time.Now().UnixNano())

	// 创建一个切片来存储随机选择的字符串
	result := make([]string, 0, n)
	// 创建一个切片用来标记已选择的索引
	usedIndices := make(map[int]struct{})

	for len(result) < n {
		// 生成随机索引
		index := rand.Intn(len(arr))
		// 检查该索引是否已被使用
		if _, exists := usedIndices[index]; !exists {
			// 如果未使用，则添加到结果中
			result = append(result, arr[index])
			// 标记该索引为已使用
			usedIndices[index] = struct{}{}
		}
	}

	return result, nil
}

func ShuffleArray(arr []int64) []int64 {
	rand.Seed(time.Now().UnixNano())
	for i := len(arr) - 1; i > 0; i-- {
		j := rand.Intn(i + 1)
		arr[i], arr[j] = arr[j], arr[i]
	}

	return arr
}

func StrToInt64(val string) int64 {
	num, err := strconv.ParseInt(val, 10, 64)
	if err != nil {
		fmt.Println("转换错误:", err)
		return 0
	}
	return num
}

func RoundToTwoDecimalPlaces(value float64) float64 {
	strValue := fmt.Sprintf("%.2f", value)
	roundedValue, err := strconv.ParseFloat(strValue, 64)
	if err != nil {
		// 处理错误
		return 0
	}
	return roundedValue
}

func ZeroUnix(unix int64) int64 {
	loc, _ := time.LoadLocation("Asia/Shanghai")
	dayTime, _ := time.ParseInLocation("2006-01-02", time.Unix(unix, 0).Format("2006-01-02"), loc)
	return dayTime.Unix()
}

func AnyToStruct(data interface{}, out interface{}) error {
	marshalData, _ := json.Marshal(data)
	return json.Unmarshal(marshalData, out)
}
